###################################################
### samplesize.NI.binary testing file #####
### 11-08-2023 #####
###################################################
# Load dani:
# library(dani)
#Initialise vector of outputs
correct<-()
n.t<-1
#####################################################
# First set of checks:
# Check that it stops for non acceptable values of expected probabilities:
out1A<-(("0.1",0.1,0.05))
correct[n.t]]<-(((out1A, "try-error"))&&(("is.numeric(p.control.expected) is not TRUE", out1A[1], fixed=T )),1,0)
(correct)[n.t]]<-"out1A"
n.t=n.t+1
out1B<-((-0.1,0.1,0.05))
correct[n.t]]<-(((out1B, "try-error"))&&(("p.control.expected > 0 is not TRUE", out1B[1], fixed=T )),1,0)
(correct)[n.t]]<-"out1B"
n.t=n.t+1
out1C<-((1,0.1,0.05))
correct[n.t]]<-(((out1C, "try-error"))&&(("p.control.expected < 1 is not TRUE", out1C[1], fixed=T )),1,0)
(correct)[n.t]]<-"out1C"
n.t=n.t+1
out1D<-((0.1,"0.1",0.05))
correct[n.t]]<-(((out1D, "try-error"))&&(("is.numeric(p.experim.target) is not TRUE", out1D[1], fixed=T )),1,0)
(correct)[n.t]]<-"out1D"
n.t=n.t+1
out1E<-((0.1,0,0.05))
correct[n.t]]<-(((out1E, "try-error"))&&(("p.experim.target > 0 is not TRUE", out1E[1], fixed=T )),1,0)
(correct)[n.t]]<-"out1E"
n.t=n.t+1
out1F<-((0.1,1.2,0.05))
correct[n.t]]<-(((out1F, "try-error"))&&(("p.experim.target < 1 is not TRUE", out1F[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out1F"
n.t=n.t+1
#####################################################
# Second set of checks:
# Check that it stops for non-acceptable margins:
out2A<-((0.1,0.1,"0.05"))
correct[n.t]]<-(((out2A, "try-error"))&&(("is.numeric(NI.margin) is not TRUE", out2A[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out2A"
n.t=n.t+1
out2B<-((0.1,0.1,-0.05, summary.measure="RR"))
correct[n.t]]<-(((out2B, "try-error"))&&(("NI margin should be >0 when summary measure is a ratio (OR or RR)", out2B[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out2B"
n.t=n.t+1
out2C<-((0.1,0.1,-0.05, summary.measure="OR"))
correct[n.t]]<-(((out2C, "try-error"))&&(("NI margin should be >0 when summary measure is a ratio (OR or RR)", out2C[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out2C"
n.t=n.t+1
out2D<-((0.1,0.1,1, summary.measure="RD"))
correct[n.t]]<-(((out2D, "try-error"))&&(("NI margin should be <1 in absolute value when summary measure is RD", out2D[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out2D"
n.t=n.t+1
out2E<-((0.1,0.1,-1.1, summary.measure="RD"))
correct[n.t]]<-(((out2E, "try-error"))&&(("NI margin should be <1 in absolute value when summary measure is RD", out2E[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out2E"
n.t=n.t+1
out2F<-((0.1,0.2,0.05, summary.measure="RD"))
correct[n.t]]<-(((out2F, "try-error"))&&(("In the alternative hypothesis the experimental treatment is not non-inferior.", out2F[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out2F"
n.t=n.t+1
out2G<-((0.9,0.8,-0.05, summary.measure="RD", unfavourable = F))
correct[n.t]]<-(((out2G, "try-error"))&&(("In the alternative hypothesis the experimental treatment is not non-inferior.", out2G[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out2G"
n.t=n.t+1
out2H<-((0.1,0.2,1.5, summary.measure="RR"))
correct[n.t]]<-(((out2H, "try-error"))&&(("In the alternative hypothesis the experimental treatment is not non-inferior.", out2H[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out2H"
n.t=n.t+1
out2I<-((0.2,0.1,0.75, summary.measure="RR", unfavourable = F))
correct[n.t]]<-(((out2I, "try-error"))&&(("In the alternative hypothesis the experimental treatment is not non-inferior.", out2I[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out2I"
n.t=n.t+1
out2J<-((0.5,0.1,0.5, summary.measure="OR", unfavourable = F))
correct[n.t]]<-(((out2J, "try-error"))&&(("In the alternative hypothesis the experimental treatment is not non-inferior.", out2J[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out2J"
n.t=n.t+1
out2K<-((0.1,0.5,2, summary.measure="OR"))
correct[n.t]]<-(((out2K, "try-error"))&&(("In the alternative hypothesis the experimental treatment is not non-inferior.", out2K[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out2K"
n.t=n.t+1
#####################################################
# Third set of checks:
# Check that it stops for unacceptable values of significance level:
out3A<-((0.1,0.1,0.05, sig.level = "0.025"))
correct[n.t]]<-(((out3A, "try-error"))&&(("is.numeric(sig.level) is not TRUE", out3A[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out3A"
n.t=n.t+1
out3B<-((0.1,0.1,0.05, sig.level=-0.1))
correct[n.t]]<-(((out3B, "try-error"))&&(("sig.level > 0 is not TRUE", out3B[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out3B"
n.t=n.t+1
out3C<-((0.1,0.1,0.05, sig.level=1))
correct[n.t]]<-(((out3C, "try-error"))&&(("sig.level < 0.5 is not TRUE", out3C[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out3C"
n.t=n.t+1
#####################################################
# Fourth set of checks:
# Check with other wrong arguments:
# Check that it stops for unacceptable values of power:
out4A<-((0.1,0.1,0.05, = "0.9"))
correct[n.t]]<-(((out4A, "try-error"))&&(("is.numeric(power) is not TRUE", out4A[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4A"
n.t=n.t+1
out4B<-((0.1,0.1,0.05, =0))
correct[n.t]]<-(((out4B, "try-error"))&&(("power > 0 is not TRUE", out4B[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4B"
n.t=n.t+1
out4C<-((0.1,0.1,0.05, =1))
correct[n.t]]<-(((out4C, "try-error"))&&(("power < 1 is not TRUE", out4C[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4C"
n.t=n.t+1
# Check that it stops for unacceptable values of allocation ratio:
out4D<-((0.1,0.1,0.05, r = "0.9"))
correct[n.t]]<-(((out4D, "try-error"))&&(("is.numeric(r) is not TRUE", out4D[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4D"
n.t=n.t+1
out4E<-((0.1,0.1,0.05, r=0))
correct[n.t]]<-(((out4E, "try-error"))&&(("r > 0 is not TRUE", out4E[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4E"
n.t=n.t+1
# Check that it works for wrong summary measure value:
out4F<-((0.1,0.1,0.05, summary.measure = "pippo"))
correct[n.t]]<-(((out4F, "try-error"))&&(("summary.measure %in%", out4F[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4F"
n.t=n.t+1
# Check that it works when print.out incorrectly specified:
out4G<-((0.1,0.1,0.05, print.out = ))
correct[n.t]]<-(((out4G, "try-error"))&&(("!is.na(print.out) is not TRUE", out4G[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4G"
n.t=n.t+1
# Check that it works when test.type incorrectly specified:
out4H<-((0.1,0.1,0.05, test.type = ))
correct[n.t]]<-(((out4H, "try-error"))&&(("is.character(test.type) is not TRUE", out4H[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4H"
n.t=n.t+1
out4I<-((0.1,0.1,0.05, test.type = "pippo"))
correct[n.t]]<-(((out4I, "try-error"))&&(("test.type %in%", out4I[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4I"
n.t=n.t+1
# Check that it works when unfavourable incorrectly specified:
out4J<-((0.1,0.1,0.05, unfavourable = ))
correct[n.t]]<-(((out4J, "try-error"))&&(("!is.na(unfavourable) is not TRUE", out4J[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4J"
n.t=n.t+1
out4K<-((0.1,0.1,0.05, unfavourable = "pippo"))
correct[n.t]]<-(((out4K, "try-error"))&&(("is.logical(unfavourable) is not TRUE", out4K[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4K"
n.t=n.t+1
# Check that it works when cont.corr incorrectly specified:
out4L<-((0.1,0.1,0.05, cont.corr = ))
correct[n.t]]<-(((out4L, "try-error"))&&(("!is.na(cont.corr) is not TRUE", out4L[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4L"
n.t=n.t+1
out4M<-((0.1,0.1,0.05, cont.corr = "pippo"))
correct[n.t]]<-(((out4M, "try-error"))&&(("is.logical(cont.corr) is not TRUE", out4M[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4M"
n.t=n.t+1
# Check that it works when round incorrectly specified:
out4N<-((0.1,0.1,0.05, = ))
correct[n.t]]<-(((out4N, "try-error"))&&(("!is.na(round) is not TRUE", out4N[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4N"
n.t=n.t+1
out4O<-((0.1,0.1,0.05, = "pippo"))
correct[n.t]]<-(((out4O, "try-error"))&&(("is.logical(round) is not TRUE", out4O[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4O"
n.t=n.t+1
# Check that it stops for unacceptable values of loss to follow up:
out4P<-((0.1,0.1,0.05, ltfu = "0.9"))
correct[n.t]]<-(((out4P, "try-error"))&&(("is.numeric(ltfu) is not TRUE", out4P[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4P"
n.t=n.t+1
out4Q<-((0.1,0.1,0.05, ltfu=-1))
correct[n.t]]<-(((out4Q, "try-error"))&&(("ltfu >= 0 is not TRUE", out4Q[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4Q"
n.t=n.t+1
out4R<-((0.1,0.1,0.05, ltfu=1))
correct[n.t]]<-(((out4R, "try-error"))&&(("ltfu < 1 is not TRUE", out4R[1] , fixed=T )),1,0)
(correct)[n.t]]<-"out4R"
n.t=n.t+1
#####################################################
# Fifth set of checks:
# Now check sample size calculations for certain values on RD scale. These are compared against results from artbin
out5A<-((0.1, p.experim.target=0.1, NI.margin=0.05, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "RD", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]]<-(((out5A,"numeric"))&&((out5A[2],757)),1,0)
(correct)[n.t]]<-"out5A"
n.t=n.t+1
out5B<-((0.1, p.experim.target=0.1, NI.margin=0.05, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "RD", print.out = , test.type="score",
unfavourable=T, cont.corr=F))
correct[n.t]]<-(((out5B,"numeric"))&&((out5B[2],775)),1,0)
(correct)[n.t]]<-"out5B"
n.t=n.t+1
out5C<-((0.1, p.experim.target=0.1, NI.margin=0.05, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "RD", print.out = , test.type="local",
unfavourable=T, cont.corr=F))
correct[n.t]]<-(((out5C,"numeric"))&&((out5C[2],787)),1,0)
(correct)[n.t]]<-"out5C"
n.t=n.t+1
out5D<-((0.1, p.experim.target=0.12, NI.margin=0.05, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "RD", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]]<-(((out5D,"numeric"))&&((out5D[2],2284)),1,0)
(correct)[n.t]]<-"out5D"
n.t=n.t+1
out5E<-((0.5, p.experim.target=0.45, NI.margin=0.4, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "RD", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]]<-(((out5E,"numeric"))&&((out5E[2],26)),1,0)
(correct)[n.t]]<-"out5E"
n.t=n.t+1
out5F<-((0.1, p.experim.target=0.1, NI.margin=0.05, sig.level = 0.05, = 0.9, r = 1,
summary.measure = "RD", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]]<-(((out5F,"numeric"))&&((out5F[2],617)),1,0)
(correct)[n.t]]<-"out5F"
n.t=n.t+1
out5G<-((0.1, p.experim.target=0.1, NI.margin=0.05, sig.level = 0.025, = 0.54, r = 1,
summary.measure = "RD", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]]<-(((out5G,"numeric"))&&((out5G[2],306)),1,0)
(correct)[n.t]]<-"out5G"
n.t=n.t+1
out5H<-((0.1, p.experim.target=0.1, NI.margin=0.05, sig.level = 0.025, = 0.9, r = 0.5,
summary.measure = "RD", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]]<-(((out5H,"numeric"))&&((out5H[2],568)),1,0)
(correct)[n.t]]<-"out5H"
n.t=n.t+1
out5I<-((0.1, p.experim.target=0.1, NI.margin=0.05, sig.level = 0.025, = 0.9, r = 2,
summary.measure = "RD", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]]<-(((out5I,"numeric"))&&((out5I[2],1135)),1,0)
(correct)[n.t]]<-"out5I"
n.t=n.t+1
out5J<-((0.1, p.experim.target=0.1, NI.margin=0.05, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "RD", print.out = , test.type="Wald",
unfavourable=T, cont.corr=T))
correct[n.t]]<-(((out5J,"numeric"))&&((out5J[2],797)),1,0)
(correct)[n.t]]<-"out5J"
n.t=n.t+1
out5K<-((0.1, p.experim.target=0.1, NI.margin=0.05, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "RD", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F, =F))
correct[n.t]]<-(((out5K,"numeric"))&&((out5K[2],756.5345, tolerance = 10(-5))),1,0)
(correct)[n.t]]<-"out5K"
n.t=n.t+1
out5L<-((0.1, p.experim.target=0.1, NI.margin=0.05, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "RD", print.out = , test.type="Wald",
unfavourable=T, cont.corr=T, ltfu=0.1))
correct[n.t]]<-(((out5L,"numeric"))&&((out5L[2],881)),1,0)
(correct)[n.t]]<-"out5L"
n.t=n.t+1
#####################################################
# Sixth set of checks:
# Now check sample size calculations for certain values on OR scale. These are compared against results from artcat
out6A<-((0.1, p.experim.target=0.1, NI.margin=1.5, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "OR", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]] <- (((out6A)) && ((out6A[2], 1421)) , 1, 0)
(correct)[n.t]] <- "out6A"
n.t <- n.t + 1
out6B<-((0.1, p.experim.target=0.1, NI.margin=1.5, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "OR", print.out = , test.type="score",
unfavourable=T, cont.corr=F))
correct[n.t]] <- (((out6B)) && ((out6B[2], 1447)) , 1, 0)
(correct)[n.t]] <- "out6B"
n.t <- n.t + 1
out6C<-((0.1, p.experim.target=0.1, NI.margin=1.5, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "OR", print.out = , test.type="local",
unfavourable=T, cont.corr=F))
correct[n.t]] <- (((out6C)) && ((out6C[2], 1464)) , 1, 0)
(correct)[n.t]] <- "out6C"
n.t <- n.t + 1
out6D<-((0.1, p.experim.target=0.12, NI.margin=1.5, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "OR", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]] <- (((out6D)) && ((out6D[2], 5371)) , 1, 0)
(correct)[n.t]] <- "out6D"
n.t <- n.t + 1
out6E<-((0.5, p.experim.target=0.45, NI.margin=3, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "OR", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]] <- (((out6E)) && ((out6E[2], 51)) , 1, 0)
(correct)[n.t]] <- "out6E"
n.t <- n.t + 1
out6F<-((0.1, p.experim.target=0.1, NI.margin=1.5, sig.level = 0.05, = 0.9, r = 1,
summary.measure = "OR", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]] <- (((out6F)) && ((out6F[2], 1158)) , 1, 0)
(correct)[n.t]] <- "out6F"
n.t <- n.t + 1
out6G<-((0.1, p.experim.target=0.1, NI.margin=1.5, sig.level = 0.025, = 0.54, r = 1,
summary.measure = "OR", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]] <- (((out6G)) && ((out6G[2], 574)) , 1, 0)
(correct)[n.t]] <- "out6G"
n.t <- n.t + 1
out6H<-((0.1, p.experim.target=0.1, NI.margin=1.5, sig.level = 0.025, = 0.9, r = 0.5,
summary.measure = "OR", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]] <- (((out6H)) && ((out6H[2], 1066)) , 1, 0)
(correct)[n.t]] <- "out6H"
n.t <- n.t + 1
out6I<-((0.1, p.experim.target=0.1, NI.margin=1.5, sig.level = 0.025, = 0.9, r = 2,
summary.measure = "OR", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]] <- (((out6I)) && ((out6I[2], 2131)) , 1, 0)
(correct)[n.t]] <- "out6I"
n.t <- n.t + 1
#####################################################
# Seventh set of checks:
# Check results against artbin and artcat for one example with favourable outcome
out7A<-((0.1, p.experim.target=0.1, NI.margin=-0.05, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "RD", print.out = , test.type="Wald",
unfavourable=F, cont.corr=F))
correct[n.t]] <- (((out7A)) && ((out7A[2], 757)) , 1, 0) # Checked against riskratio epitools
(correct)[n.t]] <- "out7A"
n.t <- n.t + 1
out7B<-((0.1, p.experim.target=0.1, NI.margin=0.75, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "OR", print.out = , test.type="Wald",
unfavourable=F, cont.corr=F))
correct[n.t]] <- (((out7B)) && ((out7B[2], 2822)) , 1, 0) # Checked against riskratio epitools
(correct)[n.t]] <- "out7B"
n.t <- n.t + 1
#####################################################
# Eight set of checks:
# Check results for RR and AS. These are just compared against known results from our paper on NI frontiers:
out8A<-((0.05, p.experim.target=0.05, NI.margin=2, sig.level = 0.025, = 0.9, r = 1,
summary.measure = "RR", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]] <- (((out8A)) && ((out8A[2], 832)) , 1, 0) # Checked against riskratio epitools
(correct)[n.t]] <- "out8A"
n.t <- n.t + 1
out8B<-((0.05, p.experim.target=0.05, NI.margin=(0.05,0.05, "RD", "AS"), sig.level = 0.025, = 0.9, r = 1,
summary.measure = "AS", print.out = , test.type="Wald",
unfavourable=T, cont.corr=F))
correct[n.t]] <- (((out8B)) && ((out8B[2], 568)) , 1, 0) # Checked against riskratio epitools
(correct)[n.t]] <- "out8B"
n.t <- n.t + 1
##################################################
#### Now summarise results
vec.correct<-(correct) # Create vector from list
number.of.tests<-n.t-1 # How many tests did we do?
tot.correct<-(vec.correct==1, na.rm = T) # How many tests gave correct result?
tot.incorrect<-(vec.correct==0, na.rm = T) # How many test gave wrong result?
tot.NA<-((vec.correct)) # How many test generated an NA?
("Testing completed. ", tot.correct, " tests out of ", number.of.tests, " behaved correctly.\n",
tot.incorrect, " tests out of ", number.of.tests, " behaved incorrectly.\n",
"An NA was produced for ", tot.NA, " tests out of ", number.of.tests, ".\n")
# Now list incorrect tests
(tot.incorrect>0) {
("Incorrect tests:\n")
(correct)[which(vec.correct==0)]
}
# Now list NA tests
if (tot.NA>0) {
("Tests returning NAs:\n")
(correct)[which((vec.correct))]
}
ss.NI.b<-(tot.correct==number.of.tests)
